package org.qengine.controller;

import com.baomidou.mybatisplus.core.metadata.IPage;
import org.qengine.entity.ClassEntity;
import org.qengine.entity.UserEntity;
import org.qengine.service.ClassService;
import org.qengine.service.UserService;
import org.qengine.vo.LoginVo;
import org.qengine.vo.UserVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import javax.persistence.EntityNotFoundException;
import java.util.List;

/**
 * 用户控制器，处理与用户相关的HTTP请求。
 */
@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService; // 用于执行用户相关业务逻辑的服务接口

    @Autowired
    private ClassService classService; // 用于执行班级相关业务逻辑的服务接口


    /**
     * 根据用户名搜索用户。
     *
     * @param userVo 包含用户名信息的视图对象
     * @return 搜索结果，如果未找到则返回404状态码和错误消息
     */
    @GetMapping("/search")
    public ResponseEntity<?> getUsersByName(@RequestBody UserVo userVo) {
        IPage<UserEntity> result = userService.search(userVo);
        if (result.getRecords().isEmpty()) {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).body("未查找到用户: " + userVo.getUserNickname());
        }
        return ResponseEntity.ok(result);
    }

    /**
     * 添加新用户。
     *
     * @param userEntity 新用户的实体对象
     * @return 如果添加成功返回200和消息，失败则返回500或409（冲突）状态码及错误信息
     */
    @PostMapping("/add")
    public ResponseEntity<String> addUser(@RequestBody UserEntity userEntity) {
        try {
            if (userService.addUser(userEntity)) {
                return ResponseEntity.ok("用户增添成功");
            } else {
                return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("用户增添失败");
            }
        } catch (UserExceptionController.DuplicateUserException e) {
            return ResponseEntity.status(HttpStatus.CONFLICT).body(e.getMessage());
        }
    }

    /**
     * 根据用户ID删除用户。
     *
     * @param id 用户的唯一标识符
     * @return 删除结果，包括成功、失败或找不到用户的情况
     */
    @DeleteMapping("/delete-by-userID/{id}")
    public ResponseEntity<Object> deleteUser(@PathVariable Long id, @RequestParam("userId") Long userId) {
        // 检查用户身份是否为老师或校长
        String userRole = userService.getUserRoleById(userId);
        if (!userRole.equals("老师") && !userRole.equals("校长")) {
            throw new UserExceptionController.ForbiddenAccessException("您不是老师或校长，无法批量导入");
        }
        try {
            boolean isDeleted = userService.deleteUserById(id);
            return isDeleted
                    ? ResponseEntity.ok("用户删除成功")
                    : ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("用户删除失败");
        } catch (EntityNotFoundException e) {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(e.getMessage());
        } catch (IllegalArgumentException e) {
            return ResponseEntity.badRequest().body(e.getMessage());
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("用户删除出错.");
        }
    }

    /**
     * 根据用户名删除用户。
     *
     * @param userNickname 用户的昵称
     * @return 删除结果，包括成功、失败或找不到用户的情况
     */
    @DeleteMapping("/delete-by-usernickname/{userNickname}")
    public ResponseEntity<String> deleteUserByUsername(@PathVariable String userNickname, @RequestParam("userId") Long userId) {
        // 检查用户身份是否为老师或校长
        String userRole = userService.getUserRoleById(userId);
        if (!userRole.equals("老师") && !userRole.equals("校长")) {
            throw new UserExceptionController.ForbiddenAccessException("您不是老师或校长，无法批量导入");
        }
        try {
            if (userService.deleteUserByUserNickname(userNickname)) {
                return ResponseEntity.ok("用户删除成功");
            } else {
                return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("用户删除失败");
            }
        } catch (EntityNotFoundException | IllegalArgumentException e) {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(e.getMessage());
        }
    }

    /**
     * 更新用户信息。
     *
     * @param id 用户的唯一标识符
     * @param vo 包含更新信息的视图对象
     * @return 更新结果，包括成功、失败或参数错误的情况
     */
    @PutMapping("/update/{id}")
    public ResponseEntity<String> updateUser(@PathVariable Long id, @RequestBody UserVo vo) {
        vo.setId(id); // 确保视图对象中的 ID 与路径参数一致
        try {
            if (userService.updateUser(vo)) {
                return ResponseEntity.ok("用户信息更新成功");
            } else {
                return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("用户信息更新失败");
            }
        } catch (IllegalArgumentException | EntityNotFoundException e) {
            return ResponseEntity.badRequest().body(e.getMessage());
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("用户信息更新出错");
        }
    }

    /**
     * 注册新用户。
     *
     * @param userEntity 新用户的实体对象
     * @return 如果注册成功返回200和消息，失败则返回400或500状态码及错误信息
     */
    @PostMapping("/register")
    public ResponseEntity<String> registerUser(@RequestBody UserEntity userEntity) {
        try {
            userService.registerUser(userEntity);
            return ResponseEntity.ok("注册成功");
        } catch (IllegalArgumentException e) {
            return ResponseEntity.badRequest().body(e.getMessage());
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("注册出错");
        }
    }

    /**
     * 用户登录验证。
     *
     * @param loginVo 包含登录信息的视图对象
     * @return 登录结果，包括成功、失败或服务器内部错误
     */
    @PostMapping("/login")
    public ResponseEntity<String> loginUser(@RequestBody LoginVo loginVo) {
        try {
            if (userService.checkPassword(loginVo)) {
                return ResponseEntity.ok("登陆成功");
            } else {
                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("账号或密码错误");
            }
        } catch (IllegalArgumentException e) {
            return ResponseEntity.badRequest().body(e.getMessage());
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("登录时出错.");
        }
    }

    /**
     * 批量导入用户。
     *
     * @param users 包含多个用户实体对象的列表
     * @return 如果批量导入成功返回200和消息，失败则返回400或500状态码及错误信息
     */
    @PostMapping("/batch-import")
    public ResponseEntity<String> batchImportUsers(@RequestBody List<UserEntity> users, @RequestParam("userId") Long userId) {
        // 检查用户身份是否为老师或校长
        String userRole = userService.getUserRoleById(userId);
        if (!userRole.equals("老师") && !userRole.equals("校长")) {
            throw new UserExceptionController.ForbiddenAccessException("您不是老师或校长，无法批量导入");
        }
        try {
            userService.batchImportUsers(users);
            return ResponseEntity.ok("批量导入成功");
        } catch (IllegalArgumentException e) {
            return ResponseEntity.badRequest().body(e.getMessage());
        } catch (UserExceptionController.DuplicateUserException e) {
            return ResponseEntity.status(HttpStatus.CONFLICT).body(e.getMessage());
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("批量导入时出现了错误");
        }
    }

    /**
     * 获取班级信息，仅限老师和校长访问。
     *
     * @param classID 班级ID
     * @param userId  请求者的用户ID，用于权限验证
     * @return 班级实体对象
     */
    @GetMapping("/getClass")
    public ClassEntity getClassByID(@RequestParam("classID") Long classID, @RequestParam("userId") Long userId) {
        // 检查用户身份是否为老师或校长
        String userRole = userService.getUserRoleById(userId);
        if (!userRole.equals("老师") && !userRole.equals("校长")) {
            throw new UserExceptionController.ForbiddenAccessException("您不是老师或校长，无法查询班级信息");
        }

        return classService.getClassByID(classID);
    }

    /**
     * 更新班级信息，仅限老师和校长访问。
     *
     * @param classEntity 包含更新信息的班级实体对象
     * @param userId      请求者的用户ID，用于权限验证
     * @return 更新后的班级实体对象
     */
    @PutMapping("/updateClass")
    public ResponseEntity<ClassEntity> updateClass(@RequestBody ClassEntity classEntity, @RequestParam("userId") Long userId) {
        // 检查用户身份是否为老师或校长
        String userRole = userService.getUserRoleById(userId);
        if (!userRole.equals("老师") && !userRole.equals("校长")) {
            throw new UserExceptionController.ForbiddenAccessException("您不是老师或校长，无法更新班级信息");
        }

        ClassEntity updatedClassEntity = classService.updateClass(classEntity);
        return ResponseEntity.status(HttpStatus.CREATED).body(updatedClassEntity);
    }

    /**
     * 删除班级信息，仅限校长访问。
     *
     * @param classID 班级ID
     * @param userId  请求者的用户ID，用于权限验证
     * @return 删除结果，包括成功、失败或找不到班级的情况
     */
    @PostMapping("/deleteClass")
    public ResponseEntity<String> deleteClass(@RequestParam("classID") Long classID, @RequestParam("userId") Long userId) {
        // 检查用户身份是否为校长
        if (!userService.getUserRoleById(userId).equals("校长")) {
            throw new UserExceptionController.ForbiddenAccessException("您不是校长，无法删除班级信息");
        }

        int result = classService.deleteClass(classID);
        if (result >= 1) {
            return ResponseEntity.ok("删除成功");
        } else {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).body("删除失败");
        }
    }

    /**
     * 获取所有班级信息，仅限校长访问。
     *
     * @param userId 请求者的用户ID，用于权限验证
     * @return 班级实体对象列表
     */
    @GetMapping("/getAllClass")
    public ResponseEntity<List<ClassEntity>> getAllClass(@RequestParam("userId") Long userId) {
        // 检查用户身份是否为校长
        if (!userService.getUserRoleById(userId).equals("校长")) {
            throw new UserExceptionController.ForbiddenAccessException("您不是校长，无法查看所有班级信息");
        }

        List<ClassEntity> allClasses = classService.getAllClass();
        return ResponseEntity.ok(allClasses);
    }
}